<!DOCTYPE html>
<html lang="en" dir="ltr" class="client-nojs">
<head>
<title>restrict type qualifier - cppreference.com</title>
<meta charset="UTF-8">
<meta name="generator" content="MediaWiki 1.21.2">
<link rel="shortcut icon" href="../../../common/favicon.ico">
<link rel="stylesheet" href="../../../common/ext.css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" href="../../../common/site_modules.css">
<style>a:lang(ar),a:lang(ckb),a:lang(fa),a:lang(kk-arab),a:lang(mzn),a:lang(ps),a:lang(ur){text-decoration:none}#toc{display:none}.editsection{display:none}
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-css:7:472787eddcf4605d11de8c7ef047234f */</style>

<script src="../../../common/startup_scripts.js"></script>
<script>if(window.mw){
mw.config.set({"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":false,"wgNamespaceNumber":0,"wgPageName":"c/language/restrict","wgTitle":"c/language/restrict","wgCurRevisionId":140147,"wgArticleId":13816,"wgIsArticle":true,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":[],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgMonthNamesShort":["","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgRelevantPageName":"c/language/restrict","wgRestrictionEdit":[],"wgRestrictionMove":[]});
}</script><script>if(window.mw){
mw.loader.implement("user.options",function(){mw.user.options.set({"ccmeonemails":0,"cols":80,"date":"default","diffonly":0,"disablemail":0,"disablesuggest":0,"editfont":"default","editondblclick":0,"editsection":0,"editsectiononrightclick":0,"enotifminoredits":0,"enotifrevealaddr":0,"enotifusertalkpages":1,"enotifwatchlistpages":0,"extendwatchlist":0,"externaldiff":0,"externaleditor":0,"fancysig":0,"forceeditsummary":0,"gender":"unknown","hideminor":0,"hidepatrolled":0,"imagesize":2,"justify":0,"math":1,"minordefault":0,"newpageshidepatrolled":0,"nocache":0,"noconvertlink":0,"norollbackdiff":0,"numberheadings":0,"previewonfirst":0,"previewontop":1,"quickbar":5,"rcdays":7,"rclimit":50,"rememberpassword":0,"rows":25,"searchlimit":20,"showhiddencats":0,"showjumplinks":1,"shownumberswatching":1,"showtoc":0,"showtoolbar":1,"skin":"cppreference2","stubthreshold":0,"thumbsize":2,"underline":2,"uselivepreview":0,"usenewrc":0,"watchcreations":0,"watchdefault":0,"watchdeletion":0,
"watchlistdays":3,"watchlisthideanons":0,"watchlisthidebots":0,"watchlisthideliu":0,"watchlisthideminor":0,"watchlisthideown":0,"watchlisthidepatrolled":0,"watchmoves":0,"wllimit":250,"variant":"en","language":"en","searchNs0":true,"searchNs1":false,"searchNs2":false,"searchNs3":false,"searchNs4":false,"searchNs5":false,"searchNs6":false,"searchNs7":false,"searchNs8":false,"searchNs9":false,"searchNs10":false,"searchNs11":false,"searchNs12":false,"searchNs13":false,"searchNs14":false,"searchNs15":false,"gadget-ColiruCompiler":1,"gadget-MathJax":1});;},{},{});mw.loader.implement("user.tokens",function(){mw.user.tokens.set({"editToken":"+\\","patrolToken":false,"watchToken":false});;},{},{});
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-js:7:9f05c6caceb9bb1a482b6cebd4c5a330 */
}</script>
<script>if(window.mw){
mw.loader.load(["mediawiki.page.startup","mediawiki.legacy.wikibits","mediawiki.legacy.ajax"]);
}</script>
<style type="text/css">/*<![CDATA[*/
.source-c {line-height: normal;}
.source-c li, .source-c pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for c
 * CSS class: source-c, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.c.source-c .de1, .c.source-c .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.c.source-c  {font-family:monospace;}
.c.source-c .imp {font-weight: bold; color: red;}
.c.source-c li, .c.source-c .li1 {font-weight: normal; vertical-align:top;}
.c.source-c .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.c.source-c .li2 {font-weight: bold; vertical-align:top;}
.c.source-c .kw1 {color: #0000dd;}
.c.source-c .kw2 {color: #0000ff;}
.c.source-c .kw3 {color: #0000dd;}
.c.source-c .kw4 {color: #0000ff;}
.c.source-c .co1 {color: #909090;}
.c.source-c .co2 {color: #339900;}
.c.source-c .coMULTI {color: #ff0000; font-style: italic;}
.c.source-c .es0 {color: #008000; font-weight: bold;}
.c.source-c .es1 {color: #008000; font-weight: bold;}
.c.source-c .es2 {color: #008000; font-weight: bold;}
.c.source-c .es3 {color: #008000; font-weight: bold;}
.c.source-c .es4 {color: #008000; font-weight: bold;}
.c.source-c .es5 {color: #008000; font-weight: bold;}
.c.source-c .br0 {color: #008000;}
.c.source-c .sy0 {color: #008000;}
.c.source-c .sy1 {color: #000080;}
.c.source-c .sy2 {color: #000040;}
.c.source-c .sy3 {color: #000040;}
.c.source-c .sy4 {color: #008080;}
.c.source-c .st0 {color: #008000;}
.c.source-c .nu0 {color: #000080;}
.c.source-c .nu6 {color:#000080;}
.c.source-c .nu8 {color:#000080;}
.c.source-c .nu12 {color:#000080;}
.c.source-c .nu16 {color:#000080;}
.c.source-c .nu17 {color:#000080;}
.c.source-c .nu18 {color:#000080;}
.c.source-c .nu19 {color:#000080;}
.c.source-c .ln-xtra, .c.source-c li.ln-xtra, .c.source-c div.ln-xtra {background-color: #ffc;}
.c.source-c span.xtra { display:block; }

/*]]>*/
</style><style type="text/css">/*<![CDATA[*/
.source-asm {line-height: normal;}
.source-asm li, .source-asm pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for asm
 * CSS class: source-asm, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.asm.source-asm .de1, .asm.source-asm .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.asm.source-asm  {font-family:monospace;}
.asm.source-asm .imp {font-weight: bold; color: red;}
.asm.source-asm li, .asm.source-asm .li1 {font-weight: normal; vertical-align:top;}
.asm.source-asm .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.asm.source-asm .li2 {font-weight: bold; vertical-align:top;}
.asm.source-asm .kw1 {color: #00007f; font-weight: bold;}
.asm.source-asm .kw2 {color: #0000ff; font-weight: bold;}
.asm.source-asm .kw3 {color: #00007f;}
.asm.source-asm .kw4 {color: #000000; font-weight: bold;}
.asm.source-asm .kw5 {color: #000000; font-weight: bold;}
.asm.source-asm .co1 {color: #666666; font-style: italic;}
.asm.source-asm .co2 {color: #adadad; font-style: italic;}
.asm.source-asm .es0 {color: #000099; font-weight: bold;}
.asm.source-asm .br0 {color: #009900; font-weight: bold;}
.asm.source-asm .sy0 {color: #339933;}
.asm.source-asm .st0 {color: #7f007f;}
.asm.source-asm .nu0 {color: #0000ff;}
.asm.source-asm .ln-xtra, .asm.source-asm li.ln-xtra, .asm.source-asm div.ln-xtra {background-color: #ffc;}
.asm.source-asm span.xtra { display:block; }

/*]]>*/
</style><!--[if lt IE 7]><style type="text/css">body{behavior:url("/mwiki/skins/cppreference2/csshover.min.htc")}</style><![endif]--></head>
<body class="mediawiki ltr sitedir-ltr ns-0 ns-subject page-c_language_restrict skin-cppreference2 action-view cpp-navbar">
        <!-- header -->
        <!-- /header -->
        <!-- content -->
<div id="cpp-content-base">
            <div id="content">
                <a id="top"></a>
                <div id="mw-js-message" style="display:none;"></div>
                                <!-- firstHeading -->
<h1 id="firstHeading" class="firstHeading">restrict type qualifier</h1>
                <!-- /firstHeading -->
                <!-- bodyContent -->
                <div id="bodyContent">
                                        <!-- tagline -->
                    <div id="siteSub">From cppreference.com</div>
                    <!-- /tagline -->
                                        <!-- subtitle -->
                    <div id="contentSub"><span class="subpages">&lt; <a href="../../c.html" title="c">c</a>‎ | <a href="../language.html" title="c/language">language</a></span></div>
                    <!-- /subtitle -->
                                                            <!-- bodycontent -->
                    <div id="mw-content-text" lang="en" dir="ltr" class="mw-content-ltr"><div class="t-navbar" style=""><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="../../c.html" title="c"> C</a><div class="t-navbar-menu"><div><div><table class="t-nv-begin" cellpadding="0" style="line-height:1.1em;">
<tr class="t-nv"><td colspan="5"> <a href="../language.html" title="c/language"> Language</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../header.html" title="c/header"> Headers</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../types.html" title="c/types"> Type support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../program.html" title="c/program"> Program utilities</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../variadic.html" title="c/variadic"> Variadic function support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../error.html" title="c/error"> Error handling</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../memory.html" title="c/memory"> Dynamic memory management</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../string.html" title="c/string"> Strings library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../algorithm.html" title="c/algorithm"> Algorithms</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../numeric.html" title="c/numeric"> Numerics</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../chrono.html" title="c/chrono"> Date and time utilities</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../io.html" title="c/io"> Input/output support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../locale.html" title="c/locale"> Localization support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../thread.html" title="c/thread"> Concurrency support</a> <span class="t-mark-rev t-since-c11">(C11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../experimental.html" title="c/experimental"> Technical Specifications</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../index.html" title="c/symbol index"> Symbol index</a> </td></tr>
</table></div><div></div></div></div></div><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="../language.html" title="c/language"> C language</a><div class="t-navbar-menu"><div><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="basic_concepts.html" title="c/language/basic concepts">Basic concepts</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../keyword.html" title="c/keyword"> Keywords</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../preprocessor.html" title="c/preprocessor"> Preprocessor</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="statements.html" title="c/language/statements"> Statements</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="expressions.html" title="c/language/expressions"> Expressions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="initialization.html" title="c/language/initialization"> Initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="declarations.html" title="c/language/declarations"> Declarations</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="functions.html" title="c/language/functions"> Functions</a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Miscellaneous</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="history.html" title="c/language/history"> History of C</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../experimental.html" title="c/experimental">Technical Specifications</a> </td></tr>
</table></div><div></div></div></div></div><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="declarations.html" title="c/language/declarations"> Declarations</a><div class="t-navbar-menu"><div><div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="pointer.html" title="c/language/pointer"> pointer</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="array.html" title="c/language/array"> array</a> </td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="enum.html" title="c/language/enum"><span class="t-lines"><span>enum</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="struct.html" title="c/language/struct"><span class="t-lines"><span>struct</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="union.html" title="c/language/union"><span class="t-lines"><span>union</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="bit_field.html" title="c/language/bit field"> bit field</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="atomic.html" title="c/language/atomic"> atomic types</a> <span class="t-mark-rev t-since-c11">(C11)</span></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="const.html" title="c/language/const"><span class="t-lines"><span>const</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="volatile.html" title="c/language/volatile"><span class="t-lines"><span>volatile</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><strong class="selflink"><span class="t-lines"><span>restrict</span></span></strong></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-c99">(C99)</span></span></span></div></div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="_Alignas.html" title="c/language/ Alignas"><span class="t-lines"><span>_Alignas</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-c11">(C11)</span></span></span></div></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="storage_duration.html" title="c/language/storage duration"> storage duration and linkage</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="extern.html" title="c/language/extern"> external and tentative definitions</a> </td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="typedef.html" title="c/language/typedef"><span class="t-lines"><span>typedef</span></span></a></div></div></td></tr>
<tr class="t-nv"><td colspan="5"><div class="t-nv-ln-table"><div><a href="static_assert.html" title="c/language/ Static assert"><span class="t-lines"><span>_Static_assert</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-c11">(C11)</span></span></span></div></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="attributes.html" title="c/language/attributes"> attributes</a> <span class="t-mark-rev t-since-c23">(C23)</span></td></tr>
</table></div>
</div><div></div></div></div></div><div class="t-navbar-sep"> </div></div>
<p>Each individual type in the C <a href="compatible_type.html" title="c/language/type">type system</a> has several <i>qualified</i> versions of that type, corresponding to one, two, or all three of the <a href="const.html" title="c/language/const">const</a>, <a href="volatile.html" title="c/language/volatile">volatile</a>, and, for pointers to object types, <i>restrict</i> qualifiers. This page describes the effects of the <i>restrict</i> qualifier.
</p><p>Only a pointer to an <a href="compatible_type.html" title="c/language/type">object type</a> <span class="t-rev-inl t-since-c23"><span>or a (possibly multi-dimensional) array thereof</span> <span><span class="t-mark-rev t-since-c23">(since C23)</span></span></span> may be restrict-qualified; in particular, the following are <i>erroneous</i>:
</p>
<ul><li> <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">int</span> <span class="kw4">restrict</span> <span class="sy2">*</span>p</span></span>
</li><li> <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">float</span> <span class="br0">(</span><span class="sy2">*</span> <span class="kw4">restrict</span> f9<span class="br0">)</span><span class="br0">(</span><span class="kw4">void</span><span class="br0">)</span></span></span>
</li></ul>
<p>Restrict semantics apply to lvalue expressions only; for example, a cast to restrict-qualified pointer or a function call returning a restrict-qualified pointer are not lvalues and the qualifier has no effect.
</p><p>During each execution of a block in which a restricted pointer <code>P</code> is declared (typically each execution of a function body in which <code>P</code> is a function parameter), if some object that is accessible through <code>P</code> (directly or indirectly) is modified, by any means, then all accesses to that object (both reads and writes) in that block must occur through <code>P</code> (directly or indirectly), otherwise the behavior is undefined:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span> n, <span class="kw4">int</span> <span class="sy2">*</span> <span class="kw4">restrict</span> p, <span class="kw4">int</span> <span class="sy2">*</span> <span class="kw4">restrict</span> q<span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw1">while</span><span class="br0">(</span>n<span class="sy2">--</span> <span class="sy1">&gt;</span> <span class="nu0">0</span><span class="br0">)</span>
        <span class="sy2">*</span>p<span class="sy2">++</span> <span class="sy1">=</span> <span class="sy2">*</span>q<span class="sy2">++</span><span class="sy4">;</span> <span class="co1">// none of the objects modified through *p is the same</span>
                     <span class="co1">// as any of the objects read through *q</span>
                     <span class="co1">// compiler free to optimize, vectorize, page map, etc.</span>
<span class="br0">}</span>
<span class="kw4">void</span> g<span class="br0">(</span><span class="kw4">void</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw2">extern</span> <span class="kw4">int</span> d<span class="br0">[</span><span class="nu0">100</span><span class="br0">]</span><span class="sy4">;</span>
    f<span class="br0">(</span><span class="nu0">50</span>, d <span class="sy2">+</span> <span class="nu0">50</span>, d<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// OK</span>
    f<span class="br0">(</span><span class="nu0">50</span>, d <span class="sy2">+</span> <span class="nu0">1</span>, d<span class="br0">)</span><span class="sy4">;</span>  <span class="co1">// Undefined behavior: d[1] is accessed through both p and q in f</span>
<span class="br0">}</span></pre></div></div>
<p>If the object is never modified, it may be aliased and accessed through different restrict-qualified pointers (note that if the objects pointed to by aliased restrict-qualified pointers are, in turn, pointers, this aliasing can inhibit optimization).
</p><p>Assignment from one restricted pointer to another is undefined behavior, except when assigning from a pointer to an object in some outer block to a pointer in some inner block (including using a restricted pointer argument when calling a function with a restricted pointer parameter) or when returning from a function (and otherwise when the block of the from-pointer ended):
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">int</span><span class="sy2">*</span> <span class="kw4">restrict</span> p1 <span class="sy1">=</span> <span class="sy3">&amp;</span>a<span class="sy4">;</span>
<span class="kw4">int</span><span class="sy2">*</span> <span class="kw4">restrict</span> p2 <span class="sy1">=</span> <span class="sy3">&amp;</span>b<span class="sy4">;</span>
p1 <span class="sy1">=</span> p2<span class="sy4">;</span> <span class="co1">// undefined behavior</span></pre></div></div>
<p>Restricted pointers can be assigned to unrestricted pointers freely, the optimization opportunities remain in place as long as the compiler is able to analyze the code:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span> n, <span class="kw4">float</span> <span class="sy2">*</span> <span class="kw4">restrict</span> r, <span class="kw4">float</span> <span class="sy2">*</span> <span class="kw4">restrict</span> s<span class="br0">)</span> <span class="br0">{</span>
   <span class="kw4">float</span> <span class="sy2">*</span> p <span class="sy1">=</span> r, <span class="sy2">*</span> q <span class="sy1">=</span> s<span class="sy4">;</span> <span class="co1">// OK</span>
   <span class="kw1">while</span><span class="br0">(</span>n<span class="sy2">--</span> <span class="sy1">&gt;</span> <span class="nu0">0</span><span class="br0">)</span> <span class="sy2">*</span>p<span class="sy2">++</span> <span class="sy1">=</span> <span class="sy2">*</span>q<span class="sy2">++</span><span class="sy4">;</span> <span class="co1">// almost certainly optimized just like *r++ = *s++</span>
<span class="br0">}</span></pre></div></div>
 <table class="t-rev-begin">
<tr class="t-rev t-until-c23"><td>
<p>If an array type is declared with the restrict type qualifier (through the use of <a href="typedef.html" title="c/language/typedef">typedef</a>), the array type is not restrict-qualified, but its element type is:
</p>
</td>
<td><span class="t-mark-rev t-until-c23">(until C23)</span></td></tr>
<tr class="t-rev t-since-c23"><td>
<p>An array type and its element type are always considered to be identically restrict-qualified:
</p>
</td>
<td><span class="t-mark-rev t-since-c23">(since C23)</span></td></tr>
</table>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw1">typedef</span> <span class="kw4">int</span> <span class="sy2">*</span>array_t<span class="br0">[</span><span class="nu0">10</span><span class="br0">]</span><span class="sy4">;</span>
<span class="kw4">restrict</span> array_t a<span class="sy4">;</span> <span class="co1">// the type of a is int *restrict[10]</span>
<span class="co1">// Notes: clang and icc reject this on the grounds that array_t is not a pointer type</span>
<span class="kw4">void</span> <span class="sy2">*</span>unqual_ptr <span class="sy1">=</span> <span class="sy3">&amp;</span>a<span class="sy4">;</span> <span class="co1">// OK until C23; error since C23</span>
<span class="co1">// Notes: clang applies the rule in C++/C23 even in C89-C17 modes</span></pre></div></div>
<p>In a function declaration, the keyword <code>restrict</code> may appear inside the square brackets that are used to declare an array type of a function parameter. It qualifies the pointer type to which the array type is transformed:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span> m, <span class="kw4">int</span> n, <span class="kw4">float</span> a<span class="br0">[</span><span class="kw4">restrict</span> m<span class="br0">]</span><span class="br0">[</span>n<span class="br0">]</span>, <span class="kw4">float</span> b<span class="br0">[</span><span class="kw4">restrict</span> m<span class="br0">]</span><span class="br0">[</span>n<span class="br0">]</span><span class="br0">)</span><span class="sy4">;</span>
<span class="kw4">void</span> g12<span class="br0">(</span><span class="kw4">int</span> n, <span class="kw4">float</span> <span class="br0">(</span><span class="sy2">*</span>p<span class="br0">)</span><span class="br0">[</span>n<span class="br0">]</span><span class="br0">)</span> <span class="br0">{</span>
   f<span class="br0">(</span><span class="nu0">10</span>, n, p, p<span class="sy2">+</span><span class="nu0">10</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// OK</span>
   f<span class="br0">(</span><span class="nu0">20</span>, n, p, p<span class="sy2">+</span><span class="nu0">10</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// possibly undefined behavior (depending on what f does)</span>
<span class="br0">}</span></pre></div></div>
<h3><span class="mw-headline" id="Notes">Notes</span></h3>
<p>The intended use of the restrict qualifier (like the register storage class) is to promote optimization, and deleting all instances of the qualifier from all preprocessing translation units composing a conforming program does not change its meaning (i.e., observable behavior).
</p><p>The compiler is free to ignore any or all aliasing implications of uses of <code>restrict</code>.
</p><p>To avoid undefined behavior, the programmer must ensure that the aliasing assertions made by the restrict-qualified pointers are not violated.
</p><p>Many compilers provide, as a language extension, the opposite of <code>restrict</code>: an attribute indicating that pointers may alias even if their types differ: <a rel="nofollow" class="external text" href="https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-g_t_0040code_007bmay_005falias_007d-type-attribute-3667">may_alias (gcc)</a>, 
</p>
<h3><span class="mw-headline" id="Usage_patterns">Usage patterns</span></h3>
<p>There are several common usage patterns for restrict-qualified pointers:
</p>
<h4><span class="mw-headline" id="File_scope">File scope</span></h4>
<p>A file-scope restrict-qualified pointer has to point into a single array object for the duration of the program. That array object may not be referenced both through the restricted pointer and through either its declared name (if it has one) or another restricted pointer.
</p><p>File scope restricted pointers are useful in providing access to dynamically allocated global arrays; the restrict semantics make it possible to optimize references through this pointer as effectively as references to a static array through its declared name:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">float</span> <span class="sy2">*</span> <span class="kw4">restrict</span> a, <span class="sy2">*</span> <span class="kw4">restrict</span> b<span class="sy4">;</span>
<span class="kw4">float</span> c<span class="br0">[</span><span class="nu0">100</span><span class="br0">]</span><span class="sy4">;</span>
 
<span class="kw4">int</span> init<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span> <span class="br0">{</span>
   <span class="kw4">float</span> <span class="sy2">*</span> t <span class="sy1">=</span> <a href="../memory/malloc.html"><span class="kw403">malloc</span></a><span class="br0">(</span><span class="nu0">2</span><span class="sy2">*</span>n<span class="sy2">*</span><span class="kw4">sizeof</span><span class="br0">(</span><span class="kw4">float</span><span class="br0">)</span><span class="br0">)</span><span class="sy4">;</span>
   a <span class="sy1">=</span> t<span class="sy4">;</span>      <span class="co1">// a refers to 1st half</span>
   b <span class="sy1">=</span> t <span class="sy2">+</span> n<span class="sy4">;</span>  <span class="co1">// b refers to 2nd half</span>
<span class="br0">}</span>
<span class="co1">// compiler can deduce from the restrict qualifiers that</span>
<span class="co1">// there is no potential aliasing among the names a, b, and c</span></pre></div></div>
<h4><span class="mw-headline" id="Function_parameter">Function parameter</span></h4>
<p>The most popular use case for restrict-qualified pointers is the use as function parameters.
</p><p>In the following example, the compiler may infer that there is no aliasing of modified objects, and so optimize the loop aggressively.
Upon entry to f, the restricted pointer a must provide exclusive access to its associated array.  In particular, within f neither b nor c may point into the array associated with a, because neither is assigned a pointer value based on a. For b, this is evident from the const-qualifier in its declaration, but for c, an inspection of the body of f is required:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">float</span> x<span class="br0">[</span><span class="nu0">100</span><span class="br0">]</span><span class="sy4">;</span>
<span class="kw4">float</span> <span class="sy2">*</span>c<span class="sy4">;</span>
<span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span> n, <span class="kw4">float</span> <span class="sy2">*</span> <span class="kw4">restrict</span> a, <span class="kw4">float</span> <span class="sy2">*</span> <span class="kw4">const</span> b<span class="br0">)</span> <span class="br0">{</span>
    <span class="kw4">int</span> i<span class="sy4">;</span>
    <span class="kw1">for</span> <span class="br0">(</span> i<span class="sy1">=</span><span class="nu0">0</span><span class="sy4">;</span> i<span class="sy1">&lt;</span>n<span class="sy4">;</span> i<span class="sy2">++</span> <span class="br0">)</span>
       a<span class="br0">[</span>i<span class="br0">]</span> <span class="sy1">=</span> b<span class="br0">[</span>i<span class="br0">]</span> <span class="sy2">+</span> c<span class="br0">[</span>i<span class="br0">]</span><span class="sy4">;</span>
<span class="br0">}</span>
<span class="kw4">void</span> g3<span class="br0">(</span><span class="kw4">void</span><span class="br0">)</span> <span class="br0">{</span>
    <span class="kw4">float</span> d<span class="br0">[</span><span class="nu0">100</span><span class="br0">]</span>, e<span class="br0">[</span><span class="nu0">100</span><span class="br0">]</span><span class="sy4">;</span>
    c <span class="sy1">=</span> x<span class="sy4">;</span> f<span class="br0">(</span><span class="nu0">100</span>,   d,    e<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// OK</span>
           f<span class="br0">(</span> <span class="nu0">50</span>,   d, d<span class="sy2">+</span><span class="nu0">50</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// OK</span>
           f<span class="br0">(</span> <span class="nu0">99</span>, d<span class="sy2">+</span><span class="nu0">1</span>,    d<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// undefined behavior</span>
    c <span class="sy1">=</span> d<span class="sy4">;</span> f<span class="br0">(</span> <span class="nu0">99</span>, d<span class="sy2">+</span><span class="nu0">1</span>,    e<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// undefined behavior</span>
           f<span class="br0">(</span> <span class="nu0">99</span>,   e,  d<span class="sy2">+</span><span class="nu0">1</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// OK</span>
<span class="br0">}</span></pre></div></div>
<p>Note that it is permitted for c to point into the array associated with b. Note also that, for these purposes, the "array" associated with a particular pointer means only that portion of an array object which is actually referenced through that pointer.
</p><p>Note that in the example above, the compiler can infer that a and b do not alias because b's constness guarantees that it cannot become dependent on a in the body of the function. Equivalently, the programmer could write <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span> n, <span class="kw4">float</span> <span class="sy2">*</span> a, <span class="kw4">float</span> <span class="kw4">const</span> <span class="sy2">*</span> <span class="kw4">restrict</span> b<span class="br0">)</span></span></span>, in which case the compiler can reason that objects referenced through b cannot be modified, and so no modified object can be referenced using both b and a. If the programmer were to write <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span> n, <span class="kw4">float</span> <span class="sy2">*</span> <span class="kw4">restrict</span> a, <span class="kw4">float</span> <span class="sy2">*</span> b<span class="br0">)</span></span></span>, the compiler would be unable to infer non-aliasing of a and b without examining the body of the function.
</p><p>In general, it is best to explicitly annotate all non-aliasing pointers in a function's prototype with <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">restrict</span></span></span>.
</p>
<h4><span class="mw-headline" id="Block_scope">Block scope</span></h4>
<p>A block scope restrict-qualified pointer makes an aliasing assertion that is limited to its block. It allows local assertions that apply only to important blocks, such as tight loops. It also makes it possible to convert a function that takes restrict-qualified pointers into a macro:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">float</span> x<span class="br0">[</span><span class="nu0">100</span><span class="br0">]</span><span class="sy4">;</span>
<span class="kw4">float</span> <span class="sy2">*</span>c<span class="sy4">;</span>
<span class="co2">#define f3(N, A, B)                                    \
do                                                     \
{   int n = (N);                                       \
    float * restrict a = (A);                          \
    float * const    b = (B);                          \
    int i;                                             \
    for ( i=0; i&lt;n; i++ )                              \
        a[i] = b[i] + c[i];                            \
} while(0)</span></pre></div></div>
<h4><span class="mw-headline" id="Struct_members">Struct members</span></h4>
<p>The scope of the aliasing assertion made by a restrict-qualified pointer that is a member of a struct is the scope of the identifier used to access the struct.
</p><p>Even if the struct is declared at file scope, when the identifier used to access the struct has block scope, the aliasing assertions in the struct also have block scope; the aliasing assertions are only in effect within a block execution or a function call, depending on how the object of this struct type was created:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw1">struct</span> t <span class="br0">{</span>    <span class="co1">// Restricted pointers assert that   </span>
   <span class="kw4">int</span> n<span class="sy4">;</span>     <span class="co1">// members point to disjoint storage.</span>
   <span class="kw4">float</span> <span class="sy2">*</span> <span class="kw4">restrict</span> p<span class="sy4">;</span>
   <span class="kw4">float</span> <span class="sy2">*</span> <span class="kw4">restrict</span> q<span class="sy4">;</span>
<span class="br0">}</span><span class="sy4">;</span>
 
<span class="kw4">void</span> ff<span class="br0">(</span><span class="kw1">struct</span> t r, <span class="kw1">struct</span> t s<span class="br0">)</span> <span class="br0">{</span>
   <span class="kw1">struct</span> t u<span class="sy4">;</span>
   <span class="co1">// r,s,u have block scope</span>
   <span class="co1">// r.p, r.q, s.p, s.q, u.p, u.q should all point to</span>
   <span class="co1">// disjoint storage during each execution of ff.</span>
   <span class="co1">// ...</span>
<span class="br0">}</span></pre></div></div>
<h3><span class="mw-headline" id="Keywords">Keywords</span></h3>
<p><a href="../keyword/restrict.html" title="c/keyword/restrict"><tt>restrict</tt></a>
</p>
<h3><span class="mw-headline" id="Example">Example</span></h3>
<p>code generation example; compile with -S (gcc, clang, etc) or /FA (visual studio)
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="c source-c"><pre class="de1"><span class="kw4">int</span> foo<span class="br0">(</span><span class="kw4">int</span> <span class="sy2">*</span>a, <span class="kw4">int</span> <span class="sy2">*</span>b<span class="br0">)</span>
<span class="br0">{</span>
    <span class="sy2">*</span>a <span class="sy1">=</span> <span class="nu0">5</span><span class="sy4">;</span>
    <span class="sy2">*</span>b <span class="sy1">=</span> <span class="nu0">6</span><span class="sy4">;</span>
    <span class="kw1">return</span> <span class="sy2">*</span>a <span class="sy2">+</span> <span class="sy2">*</span>b<span class="sy4">;</span>
<span class="br0">}</span>
 
<span class="kw4">int</span> rfoo<span class="br0">(</span><span class="kw4">int</span> <span class="sy2">*</span><span class="kw4">restrict</span> a, <span class="kw4">int</span> <span class="sy2">*</span><span class="kw4">restrict</span> b<span class="br0">)</span>
<span class="br0">{</span>
    <span class="sy2">*</span>a <span class="sy1">=</span> <span class="nu0">5</span><span class="sy4">;</span>
    <span class="sy2">*</span>b <span class="sy1">=</span> <span class="nu0">6</span><span class="sy4">;</span>
    <span class="kw1">return</span> <span class="sy2">*</span>a <span class="sy2">+</span> <span class="sy2">*</span>b<span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Possible output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="asm source-asm"><pre class="de1"><span class="co1">; generated code on 64bit Intel platform:</span>
foo<span class="sy0">:</span>
    movl    $<span class="nu0">5</span><span class="sy0">,</span> <span class="br0">(</span><span class="sy0">%</span>rdi<span class="br0">)</span>    <span class="co1">; store 5 in *a</span>
    movl    $<span class="nu0">6</span><span class="sy0">,</span> <span class="br0">(</span><span class="sy0">%</span>rsi<span class="br0">)</span>    <span class="co1">; store 6 in *b</span>
    movl    <span class="br0">(</span><span class="sy0">%</span>rdi<span class="br0">)</span><span class="sy0">,</span> <span class="sy0">%</span><span class="kw3">eax</span>  <span class="co1">; read back from *a in case previous store modified it</span>
    addl    $<span class="nu0">6</span><span class="sy0">,</span> <span class="sy0">%</span><span class="kw3">eax</span>      <span class="co1">; add 6 to the value read from *a</span>
    <span class="kw1">ret</span>
 
rfoo<span class="sy0">:</span>
    movl      $<span class="nu0">11</span><span class="sy0">,</span> <span class="sy0">%</span><span class="kw3">eax</span>   <span class="co1">; the result is 11, a compile-time constant</span>
    movl      $<span class="nu0">5</span><span class="sy0">,</span> <span class="br0">(</span><span class="sy0">%</span>rdi<span class="br0">)</span>  <span class="co1">; store 5 in *a</span>
    movl      $<span class="nu0">6</span><span class="sy0">,</span> <span class="br0">(</span><span class="sy0">%</span>rsi<span class="br0">)</span>  <span class="co1">; store 6 in *b</span>
    <span class="kw1">ret</span></pre></div></div>
<h3><span class="mw-headline" id="References">References</span></h3>
<div class="t-ref-std-17">
<ul><li> C17 standard (ISO/IEC 9899:2018): 
</li></ul>
<dl><dd><ul><li> 6.7.3.1 Formal definition of restrict (p: 89-90)
</li></ul>
</dd></dl>
</div>
<div class="t-ref-std-11">
<ul><li> C11 standard (ISO/IEC 9899:2011): 
</li></ul>
<dl><dd><ul><li> 6.7.3.1 Formal definition of restrict (p: 123-125)
</li></ul>
</dd></dl>
</div>
<div class="t-ref-std-c99">
<ul><li> C99 standard (ISO/IEC 9899:1999): 
</li></ul>
<dl><dd><ul><li> 6.7.3.1 Formal definition of restrict (p: 110-112)
</li></ul>
</dd></dl>
</div>

<!-- 
NewPP limit report
Preprocessor visited node count: 1780/1000000
Preprocessor generated node count: 5430/1000000
Post‐expand include size: 44615/2097152 bytes
Template argument size: 9287/2097152 bytes
Highest expansion depth: 16/40
Expensive parser function count: 0/100
-->

<!-- Saved in parser cache with key mwiki1-mwiki_en_:pcache:idhash:13816-0!*!0!!en!*!* and timestamp 20220609231101 -->
</div>                    <!-- /bodycontent -->
                                        <!-- printfooter -->
                    <div class="printfooter">
                    Retrieved from "<a href="https://en.cppreference.com/mwiki/index.php?title=c/language/restrict&amp;oldid=140147">https://en.cppreference.com/mwiki/index.php?title=c/language/restrict&amp;oldid=140147</a>"                    </div>
                    <!-- /printfooter -->
                                                            <!-- catlinks -->
                    <!-- /catlinks -->
                                                            <div class="visualClear"></div>
                    <!-- debughtml -->
                                        <!-- /debughtml -->
                </div>
                <!-- /bodyContent -->
            </div>
        </div>
        <!-- /content -->
        <!-- footer -->
        <div id="cpp-footer-base" class="noprint">
            <div id="footer">
                        <div id="cpp-navigation">
            <h5>Navigation</h5>
            <ul><li><a href="https://en.cppreference.com/w/c/language/restrict">Online version</a></li><li>Offline version retrieved 2022-07-30 14:05.</li></ul></div>
                        <ul id="footer-info">
                                    <li id="footer-info-lastmod"> This page was last modified on 9 June 2022, at 16:11.</li>
                                    <li id="footer-info-viewcount">This page has been accessed 191,577 times.</li>
                            </ul>
                    </div>
        </div>
        <!-- /footer -->
        <script>if(window.mw){
mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"});
}</script>
<script src="../../../common/skin_scripts.js"></script>
<script>if(window.mw){
mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true);
}</script>
<script src="../../../common/site_scripts.js"></script>
<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-2828341-1']);
_gaq.push(['_setDomainName', 'cppreference.com']);
_gaq.push(['_trackPageview']);
</script><!-- Served in 0.039 secs. -->
	</body>
<!-- Cached 20220610000530 -->
</html>